///*******************************************************************************
// * Copyright (c) 2000, 2006 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// *     IBM Corporation - initial API and implementation
// *******************************************************************************/
//
//package org.eclipse.ui.tests.commands;
//
//import java.util.Map;
//
//import org.eclipse.swt.widgets.Display;
//import org.eclipse.swt.widgets.Shell;
//import org.eclipse.ui.IWorkbenchWindow;
//import org.eclipse.ui.commands.AbstractHandler;
//import org.eclipse.ui.commands.ExecutionException;
//import org.eclipse.ui.commands.HandlerSubmission;
//import org.eclipse.ui.commands.ICommand;
//import org.eclipse.ui.commands.IHandler;
//import org.eclipse.ui.commands.IWorkbenchCommandSupport;
//import org.eclipse.ui.commands.NotHandledException;
//import org.eclipse.ui.commands.Priority;
//import org.eclipse.ui.tests.harness.util.UITestCase;
//
///**
// * Tests that dialogs will inherit the handlers from the workbench window, if
// * none is defined for the dialog itself. It tests all of the various
// * combinations of this situation.
// * 
// * @since 3.0
// */
//public final class Bug66182Test extends UITestCase {
//
//	/**
//	 * Constructor for Bug66182Test.
//	 * 
//	 * @param name
//	 *            The name of the test
//	 */
//	public Bug66182Test(final String name) {
//		super(name);
//	}
//
//	/**
//	 * Tests that the dialog handlers will take priority. The set-up is a
//	 * workbench window with a handler registered for the command to test. Then
//	 * there is a dialog opened with a handler for the same command. The test is
//	 * to see that the dialog's handler gets priority.
//	 * 
//	 * @throws ExecutionException
//	 *             This should never happen, and indicates a problem with the
//	 *             test.
//	 * @throws NotHandledException
//	 *             Indicates that no handler was found where one should have
//	 *             been found.
//	 */
//	public final void testDialogHandlers() throws ExecutionException,
//			NotHandledException {
//		// Open a test window.
////		final IWorkbenchWindow window = openTestWindow();
////
////		// Define a handler for some random command identifier.
////		final Object windowResult = new Object();
////		final IHandler windowHandler = new AbstractHandler() {
////
////			public Object execute(Map parameterValuesByName)
////					throws ExecutionException {
////				// Do nothing.
////				return windowResult;
////			}
////		};
////		final IWorkbenchCommandSupport commandSupport = fWorkbench
////				.getCommandSupport();
////		final String commandId = "org.eclipse.ui.tests.Bug66182";
////		final Shell windowShell = window.getShell();
////		final HandlerSubmission windowSubmission = new HandlerSubmission(null,
////				windowShell, null, commandId, windowHandler, Priority.MEDIUM);
////		commandSupport.addHandlerSubmission(windowSubmission);
////
////		// Open a dialog.
////		final Shell dialogShell = new Shell(windowShell);
////		dialogShell.pack();
////		dialogShell.open();
////		final Display display = dialogShell.getDisplay();
////		while (display.readAndDispatch())
////			;
////
////		/*
////		 * Define a handler for the same command identifier, but for this
////		 * dialog.
////		 */
////		final Object dialogResult = new Object();
////		final IHandler dialogHandler = new AbstractHandler() {
////
////			public Object execute(Map parameterValuesByName)
////					throws ExecutionException {
////				// Do nothing.
////				return dialogResult;
////			}
////		};
////		final HandlerSubmission dialogSubmission = new HandlerSubmission(null,
////				dialogShell, null, commandId, dialogHandler, Priority.MEDIUM);
////		commandSupport.addHandlerSubmission(dialogSubmission);
////
////		// Check to see which handler is the right handler.
////		final ICommand command = commandSupport.getCommandManager().getCommand(
////				commandId);
////		assertSame(
////				"The active shell must be the dialog.  If you are activating other shells while this test is running, then this test will fail",
////				dialogShell, display.getActiveShell());
////		assertSame(
////				"The active workbench window must be the window created in this test.  If you are activating other workbench windows, then this test will fail",
////				windowShell, fWorkbench.getActiveWorkbenchWindow().getShell());
////		final Object result = command.execute(Collections.EMPTY_MAP);
////		assertSame(
////				"The dialog handler was not chosen when both a window and dialog handler were defined.",
////				dialogResult, result);
////
////		// Close the dialog and let the event loop spin.
////		commandSupport.removeHandlerSubmission(windowSubmission);
////		commandSupport.removeHandlerSubmission(dialogSubmission);
////		dialogShell.close();
////		while (display.readAndDispatch())
////			;
//	}
//
//	/**
//	 * Tests that, in the absence of a dialog handler, that the window handler
//	 * will be given a chance to take over. The set-up is a workbench window
//	 * with a handler registered for the command to test. Then there is a dialog
//	 * opened, but with no handler. The test is to see that the window's handler
//	 * is active.
//	 * 
//	 * @throws ExecutionException
//	 *             This should never happen, and indicates a problem with the
//	 *             test.
//	 * @throws NotHandledException
//	 *             Indicates that no handler was found where one should have
//	 *             been found.
//	 */
//	public final void testFallbackToWindow() throws ExecutionException,
//			NotHandledException {
//		// Open a test window.
////		final IWorkbenchWindow window = openTestWindow();
////
////		// Define a handler for some random command identifier.
////		final Object windowResult = new Object();
////		final IHandler windowHandler = new AbstractHandler() {
////
////			public Object execute(Map parameterValuesByName)
////					throws ExecutionException {
////				// Do nothing.
////				return windowResult;
////			}
////		};
////		final IWorkbenchCommandSupport commandSupport = fWorkbench
////				.getCommandSupport();
////		final String commandId = "org.eclipse.ui.tests.Bug66182";
////		final Shell windowShell = window.getShell();
////		final HandlerSubmission windowSubmission = new HandlerSubmission(null,
////				windowShell, null, commandId, windowHandler, Priority.MEDIUM);
////		commandSupport.addHandlerSubmission(windowSubmission);
////
////		// Open a dialog.
////		final Shell dialogShell = new Shell(windowShell);
////		final IWorkbenchContextSupport contextSupport = fWorkbench
////				.getContextSupport();
////		contextSupport.registerShell(dialogShell,
////				IWorkbenchContextSupport.TYPE_WINDOW);
////		dialogShell.pack();
////		dialogShell.open();
////		final Display display = dialogShell.getDisplay();
////		while (display.readAndDispatch())
////			;
////
////		// Check to see which handler is the right handler.
////		final ICommand command = commandSupport.getCommandManager().getCommand(
////				commandId);
////		assertSame(
////				"The active shell must be the dialog.  If you are activating other shells while this test is running, then this test will fail",
////				dialogShell, display.getActiveShell());
////		assertSame(
////				"The active workbench window must be the window created in this test.  If you are activating other workbench windows, then this test will fail",
////				windowShell, fWorkbench.getActiveWorkbenchWindow().getShell());
////		final Object result = command.execute(new HashMap());
////		assertSame(
////				"The window handler was not chosen when both a dialog was open with no handler, but the active workbench window did have a handler.",
////				windowResult, result);
////
////		// Close the dialog and let the event loop spin.
////		commandSupport.removeHandlerSubmission(windowSubmission);
////		contextSupport.unregisterShell(dialogShell);
////		dialogShell.close();
////		while (display.readAndDispatch())
////			;
//	}
//
//	/**
//	 * Tests that if a dialog is open, that the application will not fall back
//	 * to the dialog. The set-up is a workbench window with a handler registered
//	 * for the command to test. Then there is a dialog opened, but with no
//	 * handler. The test is to see that no handler is active.
//	 * 
//	 * @throws ExecutionException
//	 *             This should never happen, and indicates a problem with the
//	 *             test.
//	 * @throws NotHandledException
//	 *             Indicates that no handler was found where one should have
//	 *             been found.
//	 */
//	public final void testFallbackToWindowBlockedByDialog()
//			throws ExecutionException, NotHandledException {
//		// Open a test window.
//		final IWorkbenchWindow window = openTestWindow();
//
//		// Define a handler for some random command identifier.
//		final Object windowResult = new Object();
//		final IHandler windowHandler = new AbstractHandler() {
//
//			public Object execute(Map parameterValuesByName)
//					throws ExecutionException {
//				// Do nothing.
//				return windowResult;
//			}
//		};
//		final IWorkbenchCommandSupport commandSupport = fWorkbench
//				.getCommandSupport();
//		final String commandId = "org.eclipse.ui.tests.Bug66182";
//		final Shell windowShell = window.getShell();
//		final HandlerSubmission windowSubmission = new HandlerSubmission(null,
//				windowShell, null, commandId, windowHandler, Priority.MEDIUM);
//		commandSupport.addHandlerSubmission(windowSubmission);
//
//		// Open a dialog.
//		final Shell dialogShell = new Shell(windowShell);
//		dialogShell.pack();
//		dialogShell.open();
//		final Display display = dialogShell.getDisplay();
//		while (display.readAndDispatch())
//			;
//
//		// Check to see which handler is the right handler.
//		final ICommand command = commandSupport.getCommandManager().getCommand(
//				commandId);
//		assertSame(
//				"The active shell must be the dialog.  If you are activating other shells while this test is running, then this test will fail",
//				dialogShell, display.getActiveShell());
//		assertSame(
//				"The active workbench window must be the window created in this test.  If you are activating other workbench windows, then this test will fail",
//				windowShell, fWorkbench.getActiveWorkbenchWindow().getShell());
//		assertTrue(
//				"When a dialog is open, it should not fall back to the active workbench window.",
//				!command.isHandled());
//
//		// Close the dialog and let the event loop spin.
//		commandSupport.removeHandlerSubmission(windowSubmission);
//		dialogShell.close();
//		while (display.readAndDispatch())
//			;
//	}
//
//	/**
//	 * Tests that if the workbench window is the active shell, that its handlers
//	 * will take priority. The scenario has two handlers defined: one for the
//	 * workbench window, and one for a dialog that is not open. The workbench
//	 * window handler should be the active handler.
//	 * 
//	 * @throws ExecutionException
//	 *             This should never happen, and indicates a problem with the
//	 *             test.
//	 * @throws NotHandledException
//	 *             Indicates that no handler was found where one should have
//	 *             been found.
//	 */
//	public final void testWindow() throws ExecutionException,
//			NotHandledException {
//		// Open a test window.
////		final IWorkbenchWindow window = openTestWindow();
////
////		// Define a handler for some random command identifier.
////		final Object windowResult = new Object();
////		final IHandler windowHandler = new AbstractHandler() {
////
////			public Object execute(Map parameterValuesByName)
////					throws ExecutionException {
////				// Do nothing.
////				return windowResult;
////			}
////		};
////		final IWorkbenchCommandSupport commandSupport = fWorkbench
////				.getCommandSupport();
////		final String commandId = "org.eclipse.ui.tests.Bug66182";
////		final Shell windowShell = window.getShell();
////		final HandlerSubmission windowSubmission = new HandlerSubmission(null,
////				windowShell, null, commandId, windowHandler, Priority.MEDIUM);
////		commandSupport.addHandlerSubmission(windowSubmission);
////
////		// Create a dialog.
////		final Shell dialogShell = new Shell(windowShell);
////
////		/*
////		 * Define a handler for the same command identifier, but for this
////		 * dialog.
////		 */
////		final Object dialogResult = new Object();
////		final IHandler dialogHandler = new AbstractHandler() {
////
////			public Object execute(Map parameterValuesByName)
////					throws ExecutionException {
////				// Do nothing.
////				return dialogResult;
////			}
////		};
////		final HandlerSubmission dialogSubmission = new HandlerSubmission(null,
////				dialogShell, null, commandId, dialogHandler, Priority.MEDIUM);
////		commandSupport.addHandlerSubmission(dialogSubmission);
////
////		// Check to see which handler is the right handler.
////		final ICommand command = commandSupport.getCommandManager().getCommand(
////				commandId);
////		assertSame(
////				"The active shell must be the dialog.  If you are activating other shells while this test is running, then this test will fail",
////				windowShell, fWorkbench.getDisplay().getActiveShell());
////		assertSame(
////				"The active workbench window must be the window created in this test.  If you are activating other workbench windows, then this test will fail",
////				windowShell, fWorkbench.getActiveWorkbenchWindow().getShell());
////		final Object result = command.execute(new HashMap());
////		assertSame(
////				"The window handler was not chosen when both a dialog was open with no handler, but the active workbench window did have a handler.",
////				windowResult, result);
////
////		// Close the dialog and let the event loop spin.
////		commandSupport.removeHandlerSubmission(windowSubmission);
////		dialogShell.dispose();
//	}
//}
